const config = require('./config.js');
const { BASE_URL } = config;

const examApi = {
  getExamPapers: (params) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取试卷列表');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      // 确保category直接作为字符串传递
      const requestData = {
        category: params.category,
        page: params.page || 1,
        size: params.size || 10
      };
      console.log('请求试卷列表参数:', requestData);

      wx.request({
        url: `${BASE_URL}/api/exam/papers`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        data: requestData,
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取试卷列表失败' : '服务器响应异常';
            console.error('获取试卷列表失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  getExamPaperDetail: (paperId) => {
    console.log('开始获取试卷详情，paperId:', paperId);
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取试卷详情');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/exam/papers/${paperId}`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取试卷详情失败' : '服务器响应异常';
            console.error('获取试卷详情失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          console.log('获取到的试卷详情:', res.data);
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  getExamQuestions: (paperId) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取试卷题目');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/exam/papers/${paperId}/questions`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取试卷题目失败' : '服务器响应异常';
            console.error('获取试卷题目失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  submitExam: (userId, paperId, answers, duration) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下提交考试');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      // 将answers对象的键转换为数字类型
      const formattedAnswers = {};
      Object.keys(answers).forEach(key => {
        formattedAnswers[parseInt(key)] = answers[key];
      });

      console.log('提交的答案数据:', formattedAnswers);

      wx.request({
        url: `${BASE_URL}/api/exam/submit`,
        method: 'POST',
        header: {
          'Authorization': token,
          'Content-Type': 'application/json'
        },
        data: {
          userId: parseInt(userId),
          paperId: parseInt(paperId),
          answers: formattedAnswers,
          duration: parseInt(duration)
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '提交考试失败' : '服务器响应异常';
            console.error('提交考试失败:', errorMsg, res.data);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  getExamRecords: (userId, page = 1, size = 10) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取考试记录');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/exam/records`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        data: {
          userId,
          page,
          size
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取考试记录失败' : '服务器响应异常';
            console.error('获取考试记录失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  getSpecialExamList: (category, page = 1, size = 10) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取专项练习列表');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('请求专项练习列表，category:', category);

      wx.request({
        url: `${BASE_URL}/api/exam/papers`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        data: {
          category,  // 只使用 category 参数
          page,
          size
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取专项练习列表失败' : '服务器响应异常';
            console.error('获取专项练习列表失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          // 打印原始响应数据
          console.log('API响应数据:', res.data);
          if (res.data.records && res.data.records.length > 0) {
            console.log('第一条记录的完整数据:', JSON.stringify(res.data.records[0], null, 2));
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  getMistakes: () => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取错题列表');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/mistakes`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取错题列表失败' : '服务器响应异常';
            console.error('获取错题列表失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('获取错题列表失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },
  
  // 获取单个错题详情
  getMistakeById: (mistakeId) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下获取错题详情');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      console.log('开始获取错题详情，ID：', mistakeId);

      // 先从缓存中尝试获取所有错题
      const allMistakesCache = wx.getStorageSync('allMistakes');
      if (allMistakesCache && allMistakesCache.length > 0) {
        console.log('从缓存中查找错题：', allMistakesCache.length, '条记录');
        const mistake = allMistakesCache.find(item => item.id === mistakeId);
        if (mistake) {
          console.log('从缓存中找到错题:', mistake);
          resolve(mistake);
          return;
        }
      }

      console.log('缓存中未找到错题，从服务器获取');
      // 如果缓存中没有，则从服务器获取所有错题
      wx.request({
        url: `${BASE_URL}/api/mistakes`,
        method: 'GET',
        header: {
          'Authorization': token
        },
        success(res) {
          console.log('服务器响应:', res);
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '获取错题详情失败' : '服务器响应异常';
            console.error('获取错题详情失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          // 缓存所有错题
          wx.setStorageSync('allMistakes', res.data);
          console.log('缓存了', res.data.length, '条错题记录');
          
          // 查找指定ID的错题
          const mistake = res.data.find(item => item.id === mistakeId);
          if (mistake) {
            console.log('在服务器数据中找到错题:', mistake);
            resolve(mistake);
          } else {
            console.error('未找到指定ID的错题:', mistakeId);
            reject(new Error('未找到指定错题'));
          }
        },
        fail(err) {
          console.error('获取错题详情失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  deleteMistake: (mistakeId) => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下删除错题');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/mistakes/${mistakeId}`,
        method: 'DELETE',
        header: {
          'Authorization': token
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '删除错题失败' : '服务器响应异常';
            console.error('删除错题失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  },

  clearMistakes: () => {
    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('未登录状态下清空错题');
        wx.navigateTo({
          url: '/pages/login/index'
        });
        reject(new Error('请先登录'));
        return;
      }

      wx.request({
        url: `${BASE_URL}/api/mistakes/clear`,
        method: 'POST',
        header: {
          'Authorization': token
        },
        success(res) {
          if (res.statusCode === 401) {
            console.error('token已过期或无效');
            wx.removeStorageSync('token');
            wx.removeStorageSync('userInfo');
            wx.navigateTo({
              url: '/pages/login/index'
            });
            reject(new Error('登录已过期，请重新登录'));
            return;
          }
          
          if (res.statusCode !== 200) {
            const errorMsg = res.data ? res.data.message || '清空错题失败' : '服务器响应异常';
            console.error('清空错题失败:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          resolve(res.data);
        },
        fail(err) {
          console.error('网络请求失败:', err);
          reject(new Error('网络请求失败: ' + err.errMsg));
        }
      });
    });
  }
};

module.exports = examApi; 